#pragma once
typedef int int32_t;
typedef unsigned int uint32_t;

class TextOutput;
TextOutput& printWeakPointer(TextOutput& to, const void* val);

// ---------------------------------------------------------------------------

#define COMPARE_WEAK(_op_)                                      \
inline bool operator _op_ (const sp<T>& o) const {              \
    return m_ptr _op_ o.m_ptr;                                  \
}                                                               \
inline bool operator _op_ (const T* o) const {                  \
    return m_ptr _op_ o;                                        \
}                                                               \
template<typename U>                                            \
inline bool operator _op_ (const sp<U>& o) const {              \
    return m_ptr _op_ o.m_ptr;                                  \
}                                                               \
template<typename U>                                            \
inline bool operator _op_ (const U* o) const {                  \
    return m_ptr _op_ o;                                        \
}

class ReferenceRenamer {
protected:
	// destructor is purposedly not virtual so we avoid code overhead from
	// subclasses; we have to make it protected to guarantee that it
	// cannot be called from this base class (and to make strict compilers
	// happy).
	~ReferenceRenamer() { }
public:
	virtual void operator()(size_t i) const = 0;
};


class RefBase
{
public:
	void            incStrong(const void* id) const;
	void            decStrong(const void* id) const;

	void            forceIncStrong(const void* id) const;

	//! DEBUGGING ONLY: Get current strong ref count.
	int32_t         getStrongCount() const;

	class weakref_type
	{
	public:
		RefBase*            refBase() const;

		void                incWeak(const void* id);
		void                decWeak(const void* id);

		// acquires a strong reference if there is already one.
		bool                attemptIncStrong(const void* id);

		// acquires a weak reference if there is already one.
		// This is not always safe. see ProcessState.cpp and BpBinder.cpp
		// for proper use.
		bool                attemptIncWeak(const void* id);

		//! DEBUGGING ONLY: Get current weak ref count.
		int32_t             getWeakCount() const;

		//! DEBUGGING ONLY: Print references held on object.
		void                printRefs() const;

		//! DEBUGGING ONLY: Enable tracking for this object.
		// enable -- enable/disable tracking
		// retain -- when tracking is enable, if true, then we save a stack trace
		//           for each reference and dereference; when retain == false, we
		//           match up references and dereferences and keep only the 
		//           outstanding ones.

		void                trackMe(bool enable, bool retain);
	};

	weakref_type*   createWeak(const void* id) const;

	weakref_type*   getWeakRefs() const;

	//! DEBUGGING ONLY: Print references held on object.
	inline  void            printRefs() const { getWeakRefs()->printRefs(); }

	//! DEBUGGING ONLY: Enable tracking of object.
	inline  void            trackMe(bool enable, bool retain)
	{
		getWeakRefs()->trackMe(enable, retain);
	}

	typedef RefBase basetype;

protected:
	RefBase();
	virtual                 ~RefBase();

	//! Flags for extendObjectLifetime()
	enum {
		OBJECT_LIFETIME_STRONG = 0x0000,
		OBJECT_LIFETIME_WEAK = 0x0001,
		OBJECT_LIFETIME_MASK = 0x0001
	};

	void            extendObjectLifetime(int32_t mode);

	//! Flags for onIncStrongAttempted()
	enum {
		FIRST_INC_STRONG = 0x0001
	};

	virtual void            onFirstRef();
	virtual void            onLastStrongRef(const void* id);
	virtual bool            onIncStrongAttempted(uint32_t flags, const void* id);
	virtual void            onLastWeakRef(const void* id);

private:
	friend class weakref_type;
	class weakref_impl;

	RefBase(const RefBase& o);
	RefBase&        operator=(const RefBase& o);

private:
	friend class ReferenceMover;

	static void renameRefs(size_t n, const ReferenceRenamer& renamer);

	static void renameRefId(weakref_type* ref,
		const void* old_id, const void* new_id);

	static void renameRefId(RefBase* ref,
		const void* old_id, const void* new_id);

	weakref_impl* const mRefs;
};


template <class T>
class LightRefBase
{
public:
	inline LightRefBase() : mCount(0) { }
	inline void incStrong(__attribute__((unused)) const void* id) const {
		android_atomic_inc(&mCount);
	}
	inline void decStrong(__attribute__((unused)) const void* id) const {
		if (android_atomic_dec(&mCount) == 1) {
			delete static_cast<const T*>(this);
		}
	}
	//! DEBUGGING ONLY: Get current strong ref count.
	inline int32_t getStrongCount() const {
		return mCount;
	}

	typedef LightRefBase<T> basetype;

protected:
	inline ~LightRefBase() { }

private:
	friend class ReferenceMover;
	inline static void renameRefs(size_t n, const ReferenceRenamer& renamer) { }
	inline static void renameRefId(T* ref,
		const void* old_id, const void* new_id) { }

private:
	mutable volatile int32_t mCount;
};

// ---------------------------------------------------------------------------

template <typename T>
class wp
{
public:
	typedef typename RefBase::weakref_type weakref_type;

	inline wp() : m_ptr(0) { }

	wp(T* other);
	wp(const wp<T>& other);
	wp(const sp<T>& other);
	template<typename U> wp(U* other);
	template<typename U> wp(const sp<U>& other);
	template<typename U> wp(const wp<U>& other);

	~wp();

	// Assignment

	wp& operator = (T* other);
	wp& operator = (const wp<T>& other);
	wp& operator = (const sp<T>& other);

	template<typename U> wp& operator = (U* other);
	template<typename U> wp& operator = (const wp<U>& other);
	template<typename U> wp& operator = (const sp<U>& other);

	void set_object_and_refs(T* other, weakref_type* refs);

	// promotion to sp

	sp<T> promote() const;

	// Reset

	void clear();

	// Accessors

	inline  weakref_type* get_refs() const { return m_refs; }

	inline  T* unsafe_get() const { return m_ptr; }

	// Operators

	COMPARE_WEAK(== )
		COMPARE_WEAK(!= )
		COMPARE_WEAK(>)
		COMPARE_WEAK(<)
		COMPARE_WEAK(<= )
		COMPARE_WEAK(>= )

		inline bool operator == (const wp<T>& o) const {
		return (m_ptr == o.m_ptr) && (m_refs == o.m_refs);
	}
	template<typename U>
	inline bool operator == (const wp<U>& o) const {
		return m_ptr == o.m_ptr;
	}

	inline bool operator > (const wp<T>& o) const {
		return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
	}
	template<typename U>
	inline bool operator > (const wp<U>& o) const {
		return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
	}

	inline bool operator < (const wp<T>& o) const {
		return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
	}
	template<typename U>
	inline bool operator < (const wp<U>& o) const {
		return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
	}
	inline bool operator != (const wp<T>& o) const { return m_refs != o.m_refs; }
	template<typename U> inline bool operator != (const wp<U>& o) const { return !operator == (o); }
	inline bool operator <= (const wp<T>& o) const { return !operator > (o); }
	template<typename U> inline bool operator <= (const wp<U>& o) const { return !operator > (o); }
	inline bool operator >= (const wp<T>& o) const { return !operator < (o); }
	template<typename U> inline bool operator >= (const wp<U>& o) const { return !operator < (o); }

private:
	template<typename Y> friend class sp;
	template<typename Y> friend class wp;

	T*              m_ptr;
	weakref_type*   m_refs;
};

template <typename T>
TextOutput& operator<<(TextOutput& to, const wp<T>& val);

#undef COMPARE_WEAK

// ---------------------------------------------------------------------------
// No user serviceable parts below here.

template<typename T>
wp<T>::wp(T* other)
	: m_ptr(other)
{
	if (other) m_refs = other->createWeak(this);
}

template<typename T>
wp<T>::wp(const wp<T>& other)
	: m_ptr(other.m_ptr), m_refs(other.m_refs)
{
	if (m_ptr) m_refs->incWeak(this);
}

template<typename T>
wp<T>::wp(const sp<T>& other)
	: m_ptr(other.m_ptr)
{
	if (m_ptr) {
		m_refs = m_ptr->createWeak(this);
	}
}

template<typename T> template<typename U>
wp<T>::wp(U* other)
	: m_ptr(other)
{
	if (other) m_refs = other->createWeak(this);
}

template<typename T> template<typename U>
wp<T>::wp(const wp<U>& other)
	: m_ptr(other.m_ptr)
{
	if (m_ptr) {
		m_refs = other.m_refs;
		m_refs->incWeak(this);
	}
}

template<typename T> template<typename U>
wp<T>::wp(const sp<U>& other)
	: m_ptr(other.m_ptr)
{
	if (m_ptr) {
		m_refs = m_ptr->createWeak(this);
	}
}

template<typename T>
wp<T>::~wp()
{
	if (m_ptr) m_refs->decWeak(this);
}

template<typename T>
wp<T>& wp<T>::operator = (T* other)
{
	weakref_type* newRefs =
		other ? other->createWeak(this) : 0;
	if (m_ptr) m_refs->decWeak(this);
	m_ptr = other;
	m_refs = newRefs;
	return *this;
}

template<typename T>
wp<T>& wp<T>::operator = (const wp<T>& other)
{
	weakref_type* otherRefs(other.m_refs);
	T* otherPtr(other.m_ptr);
	if (otherPtr) otherRefs->incWeak(this);
	if (m_ptr) m_refs->decWeak(this);
	m_ptr = otherPtr;
	m_refs = otherRefs;
	return *this;
}

template<typename T>
wp<T>& wp<T>::operator = (const sp<T>& other)
{
	weakref_type* newRefs =
		other != NULL ? other->createWeak(this) : 0;
	T* otherPtr(other.m_ptr);
	if (m_ptr) m_refs->decWeak(this);
	m_ptr = otherPtr;
	m_refs = newRefs;
	return *this;
}

template<typename T> template<typename U>
wp<T>& wp<T>::operator = (U* other)
{
	weakref_type* newRefs =
		other ? other->createWeak(this) : 0;
	if (m_ptr) m_refs->decWeak(this);
	m_ptr = other;
	m_refs = newRefs;
	return *this;
}

template<typename T> template<typename U>
wp<T>& wp<T>::operator = (const wp<U>& other)
{
	weakref_type* otherRefs(other.m_refs);
	U* otherPtr(other.m_ptr);
	if (otherPtr) otherRefs->incWeak(this);
	if (m_ptr) m_refs->decWeak(this);
	m_ptr = otherPtr;
	m_refs = otherRefs;
	return *this;
}

template<typename T> template<typename U>
wp<T>& wp<T>::operator = (const sp<U>& other)
{
	weakref_type* newRefs =
		other != NULL ? other->createWeak(this) : 0;
	U* otherPtr(other.m_ptr);
	if (m_ptr) m_refs->decWeak(this);
	m_ptr = otherPtr;
	m_refs = newRefs;
	return *this;
}

template<typename T>
void wp<T>::set_object_and_refs(T* other, weakref_type* refs)
{
	if (other) refs->incWeak(this);
	if (m_ptr) m_refs->decWeak(this);
	m_ptr = other;
	m_refs = refs;
}

template<typename T>
sp<T> wp<T>::promote() const
{
	sp<T> result;
	if (m_ptr && m_refs->attemptIncStrong(&result)) {
		result.set_pointer(m_ptr);
	}
	return result;
}

template<typename T>
void wp<T>::clear()
{
	if (m_ptr) {
		m_refs->decWeak(this);
		m_ptr = 0;
	}
}

template <typename T>
inline TextOutput& operator<<(TextOutput& to, const wp<T>& val)
{
	return printWeakPointer(to, val.unsafe_get());
}

// ---------------------------------------------------------------------------

// this class just serves as a namespace so TYPE::moveReferences can stay
// private.
class ReferenceMover {
public:
	// it would be nice if we could make sure no extra code is generated
	// for sp<TYPE> or wp<TYPE> when TYPE is a descendant of RefBase:
	// Using a sp<RefBase> override doesn't work; it's a bit like we wanted
	// a template<typename TYPE inherits RefBase> template...

	template<typename TYPE> static inline
		void move_references(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {

		class Renamer : public ReferenceRenamer {
			sp<TYPE>* d;
			sp<TYPE> const* s;
			virtual void operator()(size_t i) const {
				// The id are known to be the sp<>'s this pointer
				TYPE::renameRefId(d[i].get(), &s[i], &d[i]);
			}
		public:
			Renamer(sp<TYPE>* d, sp<TYPE> const* s) : d(d), s(s) { }
			virtual ~Renamer() { }
		};

		memmove(d, s, n * sizeof(sp<TYPE>));
		TYPE::renameRefs(n, Renamer(d, s));
	}


	template<typename TYPE> static inline
		void move_references(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {

		class Renamer : public ReferenceRenamer {
			wp<TYPE>* d;
			wp<TYPE> const* s;
			virtual void operator()(size_t i) const {
				// The id are known to be the wp<>'s this pointer
				TYPE::renameRefId(d[i].get_refs(), &s[i], &d[i]);
			}
		public:
			Renamer(wp<TYPE>* d, wp<TYPE> const* s) : d(d), s(s) { }
			virtual ~Renamer() { }
		};

		memmove(d, s, n * sizeof(wp<TYPE>));
		TYPE::renameRefs(n, Renamer(d, s));
	}
};

// specialization for moving sp<> and wp<> types.
// these are used by the [Sorted|Keyed]Vector<> implementations
// sp<> and wp<> need to be handled specially, because they do not
// have trivial copy operation in the general case (see RefBase.cpp
// when DEBUG ops are enabled), but can be implemented very
// efficiently in most cases.

template<typename TYPE> inline
void move_forward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
	ReferenceMover::move_references(d, s, n);
}

template<typename TYPE> inline
void move_backward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
	ReferenceMover::move_references(d, s, n);
}

template<typename TYPE> inline
void move_forward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
	ReferenceMover::move_references(d, s, n);
}

template<typename TYPE> inline
void move_backward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
	ReferenceMover::move_references(d, s, n);
};